home *** CD-ROM | disk | FTP | other *** search
/ Ian & Stuart's Australian Mac 1993 September / September 93.iso / Archives / Sound / MIDI / MIDI Utilities / CMU Midi Toolkit / Source / filestream.c < prev    next >
C/C++ Source or Header  |  1988-01-11  |  7KB  |  251 lines
  1. #include "switches.h"
  2.  
  3. #ifdef LIGHTSPEED
  4. #include "Proto.h"
  5. #endif
  6.  
  7. #include <StdIO.h>
  8. #include "cext.h"
  9. #include "userio.h"
  10. #include "stream.h"
  11. #include "filestream.h"
  12.  
  13. #define READ_ID 30897
  14. #define WRITE_ID 16354
  15.  
  16. typedef struct my_data {
  17.     StreamProcs procs;        /* pointers to generic functions */
  18.     ushort ID;                /* indicates stream type */
  19.     FILE * fp;                /* file pointer */
  20. } *SelfPtr;
  21.  
  22. void        filestream_close(SelfPtr);
  23. int            filestream_getchar(SelfPtr);
  24. boolean        filestream_getline(SelfPtr, char *, ushort);
  25. ulong        filestream_getpos(SelfPtr);
  26. void        filestream_notImplemented(void);
  27. void        filestream_putchar(SelfPtr, int);
  28. void        filestream_putstring(SelfPtr, char *);
  29. void        filestream_setpos(SelfPtr, ulong);
  30.  
  31. /****************************************************************************
  32. *                filestream_OpenRead
  33. * Inputs:
  34. *    FILE * readFile: file to read from
  35. * Returns:
  36. *    StreamPtr: newly created file read stream
  37. * Effect:
  38. *    creates a new read stream on readFile.
  39. *    returns NULL if readFile is NULL or if there is no more memory.
  40. ****************************************************************************/
  41.  
  42. public StreamPtr filestream_OpenRead(readFile)
  43.     FILE *readFile;
  44. {
  45.     SelfPtr newStream;
  46.  
  47.     if (readFile == NULL) return NULL;
  48.     newStream = (SelfPtr) malloc(sizeof(struct my_data));
  49.     if (newStream == NULL) return NULL;
  50.  
  51.     newStream->procs.close = filestream_close;
  52.     newStream->procs.getchr = filestream_getchar;
  53.     newStream->procs.getline = filestream_getline;
  54.     newStream->procs.getpos = filestream_getpos;
  55.     newStream->procs.putchr = filestream_notImplemented;
  56.     newStream->procs.putstring = filestream_notImplemented;
  57.     newStream->procs.setpos = filestream_setpos;
  58.     newStream->ID = READ_ID;
  59.     newStream->fp = readFile;
  60.  
  61.     return (StreamPtr) newStream;
  62. }
  63.  
  64. /****************************************************************************
  65. *                filestream_OpenWrite
  66. * Inputs:
  67. *    FILE * writeFile: file to write to
  68. * Returns:
  69. *    StreamPtr: newly created file write stream
  70. * Effect:
  71. *    creates a new write stream on writeFile.
  72. *    returns NULL if writeFile is NULL or if there is no more memory.
  73. ****************************************************************************/
  74.  
  75. public StreamPtr filestream_OpenWrite(writeFile)
  76.     FILE *writeFile;
  77. {
  78.     SelfPtr newStream;
  79.  
  80.     if (writeFile == NULL) return NULL;
  81.     newStream = (SelfPtr) malloc(sizeof(struct my_data));
  82.     if (newStream == NULL) return NULL;
  83.  
  84.     newStream->procs.close = filestream_close;
  85.     newStream->procs.getchr = (int (*)()) filestream_notImplemented;
  86.     newStream->procs.getline = (boolean (*)()) filestream_notImplemented;
  87.     newStream->procs.getpos = filestream_getpos;
  88.     newStream->procs.putchr = filestream_putchar;
  89.     newStream->procs.putstring = filestream_putstring;
  90.     newStream->procs.setpos = filestream_setpos;
  91.     newStream->ID = WRITE_ID;
  92.     newStream->fp = writeFile;
  93.  
  94.     return (StreamPtr) newStream;
  95. }
  96.  
  97. /****************************************************************************
  98. *                filestream_close
  99. * Inputs:
  100. *    SelfPtr self: a file stream (read or write)
  101. * Effect:
  102. *    closes the file and frees the data structure.
  103. *    writes a terminating character to the file if this is a write stream.
  104. ****************************************************************************/
  105.  
  106. private void filestream_close(self)
  107.     SelfPtr self;
  108. {
  109.     if (self == NULL) return;
  110.     if (self->ID == WRITE_ID) {
  111.         fputc('\004', self->fp);
  112.     }
  113.     fclose(self->fp);
  114.     free((char *) self);
  115. }
  116.  
  117. /****************************************************************************
  118. *                filestream_getchar
  119. * Inputs:
  120. *    SelfPtr self: a file read stream
  121. * Returns:
  122. *    int: value of character read or -1 (EOF) if at the end of file
  123. * Effect:
  124. *    reads a character from the input file
  125. ****************************************************************************/
  126.  
  127. private int filestream_getchar(self)
  128.     SelfPtr self;
  129. {
  130.     return fgetc(self->fp);
  131. }
  132.  
  133. /****************************************************************************
  134. *                filestream_getline
  135. * Inputs:
  136. *    SelfPtr self: a file read stream
  137. *    char * buff: string to read line into
  138. *    ushort buffSize: length of buff
  139. * Returns:
  140. *    boolean: false if we are at the end of the file
  141. * Effect:
  142. *    reads a line of characters from the input file.  a line is terminated by
  143. *    either a newline or the end of the file.  if buffSize is less
  144. *    than the length of a given line, only buffSize characters are consumed.
  145. *    (which could potentially cause the client program to think there are
  146. *    line breaks where there aren't; watch out!)
  147. *    NOTE: the terminating newline character is NOT part of the string
  148. *    returned by getline. (thus, the final line in the input file looks like
  149. *    any other line regardless of whether the input file ends in a newline.)
  150. ****************************************************************************/
  151.  
  152. private boolean filestream_getline(self, line, lineSize)
  153.     SelfPtr self;
  154.     char *line;
  155.     ushort lineSize;
  156. {
  157.     register char *destPtr = line;
  158.     register char *maxDestPtr =
  159.         (destPtr + lineSize) - 1;    /* leave room for terminator char */
  160.     register int ch;
  161.  
  162.     if ((lineSize == 0) || (destPtr == NULL)) return false;
  163.  
  164.     while (destPtr < maxDestPtr) {
  165.         ch = fgetc(self->fp);
  166.         if ((ch == '\n') || (ch == EOF)) {
  167.             break;
  168.         } else {
  169.             *destPtr++ = ch;
  170.         }
  171.     }
  172.     *destPtr = '\0';
  173.     return (ch != EOF);
  174. }
  175.  
  176. /****************************************************************************
  177. *                filestream_getpos
  178. * Inputs:
  179. *    SelfPtr self: a file stream (read or write)
  180. * Returns:
  181. *    ulong: the number of characters since the beginning
  182. ****************************************************************************/
  183.  
  184. private ulong filestream_getpos(self)
  185.     SelfPtr self;
  186. {
  187.     return ftell(self->fp);
  188. }
  189.  
  190. /****************************************************************************
  191. *                filestream_notImplemented
  192. * Effect:
  193. *    prints an error message and exits.  used as a placeholder for functions
  194. *    that make no sense for a particular sort of stream (e.g. getchar for
  195. *    a write stream).
  196. ****************************************************************************/
  197.  
  198. private void filestream_notImplemented()
  199. {
  200.     gprintf(FATAL, "(filestream.c): operation not implemented/n");
  201.     exit(-1);
  202. }
  203.  
  204. /****************************************************************************
  205. *                filestream_putchar
  206. * Inputs:
  207. *    SelfPtr self: a file write stream
  208. *    int ch: the integer value of the character to write
  209. * Effect:
  210. *    writes ch to the file
  211. ****************************************************************************/
  212.  
  213. private void filestream_putchar(self, ch)
  214.     SelfPtr self;
  215.     int ch;
  216. {
  217.     fputc((char) ch, self->fp);
  218. }
  219.  
  220. /****************************************************************************
  221. *                filestream_putstring
  222. * Inputs:
  223. *    SelfPtr self: a file write stream
  224. *    char * s: the string to put
  225. * Effect:
  226. *    writes the given string to the file
  227. ****************************************************************************/
  228.  
  229. private void filestream_putstring(self, s)
  230.     SelfPtr self;
  231.     char *s;
  232. {
  233.     fputs(s, self->fp);
  234. }
  235.  
  236. /****************************************************************************
  237. *                filestream_setpos
  238. * Inputs:
  239. *    SelfPtr self: a file stream (read or write)
  240. *    ulong newPos: the new position
  241. * Effect:
  242. *    sets file position to newPos
  243. ****************************************************************************/
  244.  
  245. private void filestream_setpos(self, newPos)
  246.     SelfPtr self;
  247.     ulong newPos;
  248. {
  249.     fseek(self->fp, newPos, 0);
  250. }
  251.